const fs = require('fs').promises;
const path = require('path');

// 定义日志目录路径
const logDir = path.join(__dirname, '/static/logs');

// 确保日志目录存在
(async () => {
    try {
        await fs.mkdir(logDir, { recursive: true });
    } catch (err) {
        console.error('Error creating log directory:', err);
    }
})();

// 定义日志文件大小限制（2MB）
const LOG_FILE_SIZE_LIMIT = 2 * 1024 * 1024; // 2MB in bytes

// 创建日志记录数组
let logArr = [];

// 创建日志记录函数
function logMessage(message) {
    const currentDate = new Date();
    const timestr = currentDate.toLocaleString();
    const logEntry = `[${timestr}] ${message}\n`;

    // 将日志条目添加到数组中
    logArr.push(logEntry);
}

// 定期将日志数组写入文件
async function flushLogsToFile() {
    // 定时 把来源数据写入文件中
    flushFromDataToFile();

    if (logArr.length === 0) return;

    const currentDate = new Date();
    const dateStr = currentDate.toISOString().split('T')[0]; // 获取当前日期，格式为 YYYY-MM-DD
    const logFilePath = path.join(logDir, `${dateStr}.log`); // 生成日志文件路径

    try {
        // 检查日志文件是否存在且大小是否超过限制
        const stats = await fs.stat(logFilePath);
        if (stats.size >= LOG_FILE_SIZE_LIMIT) {
            // 重命名当前日志文件
            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
            const newLogFilePath = path.join(logDir, `${dateStr}-${timestamp}.log`);
            await fs.rename(logFilePath, newLogFilePath);
            // console.log(`[${currentDate.toLocaleString()}] Log file ${logFilePath} exceeded 1MB, renamed to ${newLogFilePath}`);
        }
    } catch (err) {
        if (err.code !== 'ENOENT') {
            console.error(`[${currentDate.toLocaleString()}] Error checking log file size:`, err);
        }
    }

    // 将日志数组内容写入文件
    try {
        await fs.appendFile(logFilePath, logArr.join(''));
        logArr = []; // 清空日志数组
    } catch (err) {
        console.error(`[${currentDate.toLocaleString()}] Error writing to log file:`, err);
    }
}

function onImmediatelySaveLog() {
    flushLogsToFile();
    flushFromDataToFile();
}

async function onGetLog(logTime) {
    try {
        // 读取日志目录下的所有文件
        const files = await fs.readdir(logDir);

        // 筛选出文件名包含 logTime 的文件
        const matchingFiles = files.filter(file => file.includes(logTime));

        // 如果没有匹配的文件，返回空字符串或适当的提示
        if (matchingFiles.length === 0) {
            return `No log files found for ${logTime}`;
        }

        // 读取每个匹配文件的内容并合并
        const logContents = await Promise.all(matchingFiles.map(async file => {
            const filePath = path.join(logDir, file);
            return await fs.readFile(filePath, 'utf-8');
        }));

        // 合并所有文件内容
        const combinedLogContent = logContents.join('\n');

        // 返回合并后的日志内容
        return combinedLogContent;
    } catch (err) {
        console.error(`Error getting log for ${logTime}:`, err);
        return `Error getting log for ${logTime}: ${err.message}`;
    }
}

// -----------------------------------------------------------------

const fromDir = path.join(__dirname, 'static/from');
// 定义来源文件的路径
const youxifromPath = 'static/from/youxifrom.txt';
// 来源记录数组
let fromArr = [];
// 创建来源记录函数
function writeFromMeg(message) {
    const str1 = `${message}\n`;

    // 将来源条目添加到数组中
    fromArr.push(str1);
}

// 定期将来源数组写入文件
async function flushFromDataToFile() {
    if (fromArr.length === 0) return;

    try {
        await fs.appendFile(youxifromPath, fromArr.join(''));
        fromArr = []; // 清空日志数组
        // 检查文件是否存在并获取其大小
        let stats;
        try {
            stats = await fs.stat(youxifromPath);
        } catch (err) {
            // 如果文件不存在，初始化一个空文件
            await fs.writeFile(youxifromPath, '');
            stats = { size: 0 };
        }

        // 判断是否超过 5MB（5 * 1024 * 1024 bytes）
        if (stats.size > 5 * 1024 * 1024) {
            const dateSuffix = formatTime("yyyy-MM-dd-HH-mm-ss");
            const backupFileName = youxifromPath.replace('.txt', `-${dateSuffix}.txt`);

            // 备份原文件
            await fs.rename(youxifromPath, backupFileName);

            // 创建新的空文件
            await fs.writeFile(youxifromPath, '');
        }
    } catch (e) {
        console.error('Failed to write youxifromPath:', e);
    }
}
async function onGetFrom() {
    try {
        // 读取来源目录下的所有文件
        const files = await fs.readdir(fromDir);

        // 过滤出 txt 文件
        const txtFiles = files.filter(file => path.extname(file) === '.txt');

        // 存储所有解析后的数据
        let allData = [];

        // 遍历每个文件
        for (const file of txtFiles) {
            const filePath = path.join(fromDir, file);

            // 读取文件内容
            const content = await fs.readFile(filePath, 'utf-8');

            // 按行拆分
            const lines = content.split('\n').filter(line => line.trim() !== '');

            // 解析每一行
            for (const line of lines) {
                // 按 ',' 拆分键值对
                const pairs = line.split(',').filter(pair => pair.trim() !== '');

                // 创建数据对象
                let dataObject = {};

                // 解析每个键值对
                for (const pair of pairs) {
                    const [key, value] = pair.split('=');
                    if (key && value !== undefined && value !== '') {
                        dataObject[key.trim()] = value.trim();
                    }
                    else {
                        dataObject = null;
                        break;
                    }
                }
                if (dataObject == null) {
                    continue;
                }

                // 如果解析出了数据，则添加到数组中
                if (Object.keys(dataObject).length > 0) {
                    // 检查是否已存在具有相同唯一标识符的数据
                    const isDuplicate = allData.some(existingData =>
                        (existingData.openId === dataObject.openId) &&
                        (existingData.from === dataObject.from) &&
                        (existingData.model === dataObject.model)
                    );

                    // 如果不是重复数据，则添加到数组中
                    if (!isDuplicate) {
                        allData.push(dataObject);
                    }
                }
            }
        }

        return allData;
    } catch (err) {
        console.error('Error reading from directory:', err);
        throw err; // 抛出错误以便调用者可以处理
    }
}

function formatTime(format = "yyyy-MM-dd HH:mm:ss") {
    const date = new Date();
    const year = date.getFullYear();
    const month = date.getMonth() + 1; // 月份是从 0 开始的，所以需要加 1
    const day = date.getDate();
    const hours = date.getHours();
    const minutes = date.getMinutes();
    const seconds = date.getSeconds();

    const formattedDate = format
        .replace("yyyy", `${year}`)
        .replace("MM", month < 10 ? `0${month}` : `${month}`)
        .replace("dd", day < 10 ? `0${day}` : `${day}`)
        .replace("HH", hours < 10 ? `0${hours}` : `${hours}`)
        .replace("mm", minutes < 10 ? `0${minutes}` : `${minutes}`)
        .replace("ss", seconds < 10 ? `0${seconds}` : `${seconds}`);

    return formattedDate;
}


// 每隔2分钟将日志数组写入文件
setInterval(flushLogsToFile, 2 * 60 * 1000);

module.exports = {
    logMessage, onImmediatelySaveLog, onGetLog, writeFromMeg, onGetFrom
};